{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Table of Contents](./table_of_contents.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Preface"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "\\addcontentsline{toc}{chapter}{Preface}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <style>\n",
       "        .output_wrapper, .output {\n",
       "            height:auto !important;\n",
       "            max-height:100000px;\n",
       "        }\n",
       "        .output_scroll {\n",
       "            box-shadow:none !important;\n",
       "            webkit-box-shadow:none !important;\n",
       "        }\n",
       "        </style>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#format the book\n",
    "import book_format\n",
    "book_format.set_style()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Introductory textbook for Kalman filters and Bayesian filters. The book is written using Jupyter Notebook so you may read the book in your browser and also run and modify the code, seeing the results inside the book. What better way to learn?\n",
    "\n",
    "卡尔曼滤波器和贝叶斯滤波器的入门教科书。本书使用 Jupyter Notebook 编写，因此您可以在浏览器中阅读本书，也可以运行和修改代码，查看书中的结果。还有什么比这更好的学习方法吗？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Kalman and Bayesian Filters\n",
    "## 卡尔曼和贝叶斯滤波器\n",
    "\n",
    "Sensors are noisy. The world is full of data and events that we want to measure and track, but we cannot rely on sensors to give us perfect information. The GPS in my car reports altitude. Each time I pass the same point in the road it reports a slightly different altitude. My kitchen scale gives me different readings if I weigh the same object twice.\n",
    "\n",
    "传感器噪音很大。这个世界充满了我们想要测量和跟踪的数据和事件，但我们不能依赖传感器来提供完美的信息。我车上的 GPS 会报告海拔高度。每次我经过路上的同一点时，它都会报告略有不同的海拔高度。如果我两次称量同一个物体，我的厨房秤会给出不同的读数。\n",
    "\n",
    "In simple cases the solution is obvious. If my scale gives slightly different readings I can just take a few readings and average them. Or I can replace it with a more accurate scale. But what do we do when the sensor is very noisy, or the environment makes data collection difficult? We may be trying to track the movement of a low flying aircraft. We may want to create an autopilot for a drone, or ensure that our farm tractor seeded the entire field. I work on computer vision, and I need to track moving objects in images, and the computer vision algorithms create very noisy and unreliable results. \n",
    "\n",
    "在简单情况下，解决方案显而易见。如果我的秤给出的读数略有不同，我可以取几个读数并取平均值。或者我可以用更精确的秤替换它。但是，当传感器非常嘈杂或环境使数据收集变得困难时，我们该怎么办？我们可能试图跟踪低空飞行的飞机的运动。我们可能想为无人机创建自动驾驶仪，或者确保我们的农用拖拉机播种整个田地。我从事计算机视觉工作，我需要跟踪图像中的移动物体，而计算机视觉算法会产生非常嘈杂且不可靠的结果。\n",
    "\n",
    "This book teaches you how to solve these sorts of filtering problems. I use many different algorithms, but they are all based on *Bayesian probability*. In simple terms Bayesian probability determines what is likely to be true based on past information. \n",
    "\n",
    "本书将教您如何解决此类过滤问题。我使用了许多不同的算法，但它们都基于“贝叶斯概率”。简单来说，贝叶斯概率根据过去的信息确定什么可能是真的。\n",
    "\n",
    "If I asked you the heading of my car at this moment you would have no idea. You'd proffer a number between $1^\\circ$ and $360^\\circ$ degrees, and have a 1 in 360 chance of being right. Now suppose I told you that 2 seconds ago its heading was $243^\\circ$. In 2 seconds my car could not turn very far so you could make a far more accurate prediction. You are using past information to more accurately infer information about the present or future. \n",
    "\n",
    "如果我此刻问你我的车的行驶方向，你肯定不知道。你会给出一个介于 $1^\\circ$ 到 $360^\\circ$ 度之间的数字，并且有 1/360 的机会正确。现在假设我告诉你 2 秒前它的行驶方向是 $243^\\circ$。2 秒内我的车就转不了多远，所以你可以做出更准确的预测。你正在使用过去的信息来更准确地推断有关现在或未来的信息。\n",
    "\n",
    "The world is also noisy. That prediction helps you make a better estimate, but it also subject to noise. I may have just braked for a dog or swerved around a pothole. Strong winds and ice on the road  are external influences on the path of my car. In control literature we call this *noise* though you may not think of it that way. \n",
    "\n",
    "世界也是嘈杂的。这种预测有助于您做出更好的估计，但它也会受到噪音的影响。我可能刚刚因为有狗而刹车，或者在坑洼处转弯。强风和路上的冰都是对我的车行进路线的外部影响。在控制文献中，我们称之为*噪音*，尽管您可能不这么认为。\n",
    "\n",
    "There is more to Bayesian probability, but you have the main idea. Knowledge is uncertain, and we alter our beliefs based on the strength of the evidence. Kalman and Bayesian filters blend our noisy and limited knowledge of how a system behaves with the noisy and limited sensor readings to produce the best possible estimate of the state of the system. Our principle is to never discard information. \n",
    "\n",
    "贝叶斯概率还有更多内容，但您已经了解了主要思想。知识是不确定的，我们会根据证据的强度改变我们的信念。卡尔曼和贝叶斯滤波器将我们对系统行为的嘈杂且有限的知识与嘈杂且有限的传感器读数相结合，以产生对系统状态的最佳估计。我们的原则是绝不丢弃信息。\n",
    "\n",
    "Say we are tracking an object and a sensor reports that it suddenly changed direction. Did it really turn, or is the data noisy? It depends. If this is a jet fighter we'd be very inclined to believe the report of a sudden maneuver. If it is a freight train on a straight track we would discount it. We'd further modify our belief depending on how accurate the sensor is. Our beliefs depend on the past and on our knowledge of the system we are tracking and on the characteristics of the sensors. \n",
    "\n",
    "假设我们正在跟踪一个物体，传感器报告说它突然改变了方向。它真的转弯了吗，还是数据有噪声？这要看情况。如果这是一架喷气式战斗机，我们很倾向于相信突然机动的报告。如果这是一列在直轨上的货运列车，我们会不相信它。我们会根据传感器的精确度进一步修改我们的信念。我们的信念取决于过去、我们对正在跟踪的系统的了解以及传感器的特性。\n",
    "\n",
    "The Kalman filter was invented by Rudolf Emil Kálmán to solve this sort of problem in a mathematically optimal way. Its first use was on the Apollo missions to the moon, and since then it has been used in an enormous variety of domains. There are Kalman filters in aircraft, on submarines, and on cruise missiles. Wall street uses them to track the market. They are used in robots, in IoT (Internet of Things) sensors, and in laboratory instruments. Chemical plants use them to control and monitor reactions. They are used to perform medical imaging and to remove noise from cardiac signals. If it involves a sensor and/or time-series data, a Kalman filter or a close relative to the Kalman filter is usually involved.\n",
    "\n",
    "卡尔曼滤波器是由鲁道夫·埃米尔·卡尔曼发明的，它以数学上最优的方式解决了这类问题。它首次用于阿波罗登月任务，从那时起，它就被用在了各种各样的领域。飞机、潜艇和巡航导弹上都有卡尔曼滤波器。华尔街用它们来跟踪市场。它们用于机器人、物联网 (IoT) 传感器和实验室仪器。化工厂用它们来控制和监测反应。它们用于进行医学成像和消除心脏信号中的噪音。如果涉及传感器和/或时间序列数据，通常会涉及卡尔曼滤波器或与卡尔曼滤波器密切相关的滤波器。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Motivation for this Book\n",
    "## 本书的动机\n",
    "\n",
    "I'm a software engineer that spent almost two decades in aerospace, and so I have always been 'bumping elbows' with the Kalman filter, but never implemented one. They've always had a fearsome reputation for difficulty. The theory is beautiful, but quite difficult to learn if you are not already well trained in topics such as signal processing, control theory, probability and statistics, and guidance and control theory. As I moved into solving tracking problems with computer vision the need to implement them myself became urgent. \n",
    "\n",
    "我是一名软件工程师，在航空航天业工作了近二十年，因此我一直与卡尔曼滤波器“碰碰运气”，但从未实现过。它们一直以难度大而著称。该理论很美妙，但如果你没有在信号处理、控制理论、概率和统计以及制导和控制理论等主题上训练有素，那么学习起来会相当困难。当我开始用计算机视觉解决跟踪问题时，自己实现它们的需求变得迫切起来。\n",
    "\n",
    "There are excellent textbooks in the field, such as Grewal and Andrew's *Kalman Filtering*. But sitting down and trying to read many of these books is a dismal and trying experience if you do not have the necessary background. Typically the first few chapters fly through several years of undergraduate math, blithely referring you to textbooks on Itō calculus, and presenting an entire semester's worth of statistics in a few brief paragraphs. They are textbooks for an upper undergraduate  or graduate level course, and an invaluable reference to researchers and professionals, but the going is truly difficult for the more casual reader. Notation is introduced without explanation, different texts use different words and variable names for the same concept, and the books are almost devoid of examples or worked problems. I often found myself able to parse the words and comprehend the mathematics of a definition, but had no idea as to what real world phenomena these words and math were attempting to describe. \"But what does that *mean?*\" was my repeated thought. Here are typical examples which once puzzled me:\n",
    "\n",
    "这个领域有很多优秀的教科书，比如 Grewal 和 Andrew 的《卡尔曼滤波》。但是，如果你没有必要的背景知识，坐下来尝试阅读这些书籍中的许多书籍将是一种令人沮丧和艰难的经历。通常，前几章会快速介绍几年的本科数学，轻率地向你推荐伊藤微积分教科书，并在几个简短的段落中介绍整个学期的统计数据。它们是本科高年级或研究生课程的教科书，也是研究人员和专业人士的宝贵参考资料，但对于更普通的读者来说，这确实很难。符号的介绍没有解释，不同的文本对同一概念使用不同的单词和变量名，而且这些书几乎没有例子或练习题。我经常发现自己能够解析单词并理解定义的数学原理，但不知道这些单词和数学试图描述什么现实世界现象。“但这是什么意思？”我反复想到。以下是曾经让我困惑的典型例子：\n",
    "\n",
    "$$\\begin{aligned}\\hat{x}_{k} = \\Phi_{k}\\hat{x}_{k-1} + G_k u_{k-1} + K_k [z_k - H \\Phi_{k} \\hat{x}_{k-1} - H G_k u_{k-1}]\n",
    "\\\\ \n",
    "\\mathbf{P}_{k\\mid k} = (I - \\mathbf{K}_k \\mathbf{H}_{k})\\textrm{cov}(\\mathbf{x}_k - \\hat{\\mathbf{x}}_{k\\mid k-1})(I - \\mathbf{K}_k \\mathbf{H}_{k})^{\\text{T}}  + \\mathbf{K}_k\\textrm{cov}(\\mathbf{v}_k )\\mathbf{K}_k^{\\text{T}}\\end{aligned}$$\n",
    "\n",
    "However, as I began to finally understand the Kalman filter I realized the underlying concepts are quite straightforward. If you know a few simple probability rules, and have some intuition about how we fuse uncertain knowledge, the concepts of the Kalman filter are accessible. Kalman filters have a reputation for difficulty, but shorn of much of the formal terminology the beauty of the subject and of their math became clear to me, and I fell in love with the topic. \n",
    "\n",
    "然而，当我终于开始理解卡尔曼滤波器时，我意识到底层概念相当简单。如果你知道一些简单的概率规则，并且对我们如何融合不确定的知识有一些直觉，那么卡尔曼滤波器的概念是可以理解的。卡尔曼滤波器以难理解而闻名，但除去许多正式术语，我就能清楚地了解这个主题及其数学之美，我爱上了这个主题。\n",
    "\n",
    "As I began to understand the math and theory more difficulties appeared. A book or paper will make some statement of fact and presents a graph as proof.  Unfortunately, why the statement is true is not clear to me, or I cannot reproduce the plot. Or maybe I wonder \"is this true if R=0?\"  Or the author provides pseudocode at such a high level that the implementation is not obvious. Some books offer Matlab code, but I do not have a license to that expensive package. Finally, many books end each chapter with many useful exercises. Exercises which you need to understand if you want to implement Kalman filters for yourself, but exercises with no answers. If you are using the book in a classroom, perhaps this is okay, but it is terrible for the independent reader. I loathe that an author withholds information from me, presumably to avoid 'cheating' by the student in the classroom.\n",
    "\n",
    "当我开始理解数学和理论时，出现了更多的困难。一本书或一篇论文会陈述一些事实，并给出一个图表作为证据。不幸的是，我不清楚为什么这个陈述是正确的，或者我无法重现情节。或者我可能想知道“如果 R=0，这是真的吗？”或者作者提供的伪代码太高了，以至于实现并不明显。有些书提供了 Matlab 代码，但我没有这个昂贵软件包的许可证。最后，许多书在每一章的末尾都有许多有用的练习。如果你想自己实现卡尔曼滤波器，你需要理解这些练习，但练习没有答案。如果你在课堂上使用这本书，也许这样没问题，但对于独立读者来说，这很糟糕。我讨厌作者向我隐瞒信息，大概是为了避免学生在课堂上“作弊”。\n",
    "\n",
    "All of this impedes learning. I want to track an image on a screen, or write some code for my Arduino project. I want to know how the plots in the book are made, and to choose different parameters than the author chose. I want to run simulations. I want to inject more noise into the signal and see how a filter performs. There are thousands of opportunities for using Kalman filters in everyday code, and yet this fairly straightforward topic is the provenance of rocket scientists and academics.\n",
    "\n",
    "所有这些都妨碍了学习。我想跟踪屏幕上的图像，或者为我的 Arduino 项目编写一些代码。我想知道书中的情节是如何制作的，并选择与作者不同的参数。我想运行模拟。我想向信号中注入更多噪声，看看滤波器的性能如何。在日常代码中使用卡尔曼滤波器的机会成千上万，然而这个相当简单的主题却是火箭科学家和学者的起源。\n",
    "\n",
    "I wrote this book to address all of those needs. This is not the sole book for you if you design military radars. Go get a Masters or PhD at a great STEM school, because you'll need it. This book is for the hobbyist, the curious, and the working engineer that needs to filter or smooth data. If you are a hobbyist this book should provide everything you need. If you are serious about Kalman filters you'll need more. My intention is to introduce enough of the concepts and mathematics to make the textbooks and papers approachable.\n",
    "\n",
    "我写这本书就是为了满足所有这些需求。如果你设计军用雷达，这本书不是唯一适合你的书。去一所优秀的 STEM 学校攻读硕士或博士学位，因为你会需要它。这本书适合业余爱好者、好奇者和需要过滤或平滑数据的在职工程师。如果你是业余爱好者，这本书应该能满足你所​​有的需求。如果你对卡尔曼滤波器很认真，你会需要更多。我的目的是介绍足够多的概念和数学，使教科书和论文更容易理解。\n",
    "\n",
    "This book is interactive. While you can read it online as static content, I urge you to use it as intended. It is written using Jupyter Notebook. This allows me to combine text, math, Python, and Python output in one place. Every plot, every piece of data in this book is generated from Python inside the notebook. Want to double the value of a parameter? Just change the parameter's value, and press CTRL-ENTER. A new plot or printed output will appear. \n",
    "\n",
    "本书是交互式的。虽然您可以在线阅读静态内容，但我建议您按预期使用它。它是使用 Jupyter Notebook 编写的。这使我能够将文本、数学、Python 和 Python 输出合并到一个地方。本书中的每个图表、每条数据都是由笔记本内的 Python 生成的。想要将参数的值翻倍吗？只需更改参数的值，然后按 CTRL-ENTER。将出现新的图表或打印输出。\n",
    "\n",
    "This book has exercises, but it also has the answers. I trust you. If you just need an answer, go ahead and read the answer. If you want to internalize this knowledge, try to implement the exercise before you read the answer. Since the book is interactive, you enter and run your solution inside the book - you don't have to move to a different environment, or deal with importing a bunch of stuff before starting.\n",
    "\n",
    "这本书有练习，但也有答案。我相信你。如果你只是需要一个答案，那就继续阅读答案吧。如果你想内化这些知识，试着在阅读答案之前先做练习。由于这本书是交互式的，你可以在书中输入并运行你的解决方案——你不必在开始之前转移到不同的环境，也不必导入一堆东西。\n",
    "\n",
    "This book is free. I've spent several thousand dollars on Kalman filtering books. I cannot believe they are within the reach of someone in a depressed economy or a financially struggling student. I have gained so much from free software like Python, and free books like those from Allen B. Downey  [1]. It's time to repay that. So, the book is free, it is hosted on free servers at GitHub, and it uses only free and open software such as IPython and MathJax.\n",
    "\n",
    "这本书是免费的。我花了几千美元买了卡尔曼滤波方面的书。我不敢相信经济不景气的人或经济困难的学生能买得起这些书。我从 Python 等免费软件和 Allen B. Downey [1] 等免费书籍中获益良多。是时候回报这些了。所以，这本书是免费的，它托管在 GitHub 的免费服务器上，并且只使用 IPython 和 MathJax 等免费开放软件。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading Online"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>GitHub</b>\n",
    "\n",
    "The book is hosted on GitHub, and you can read any chapter by clicking on its name. GitHub statically renders Jupyter Notebooks. You will not be able to run or alter the code, but you can read all of the content.\n",
    "\n",
    "本书托管在 GitHub 上，您可以通过单击其名称来阅读任何章节。GitHub 静态呈现 Jupyter Notebooks。您将无法运行或更改代码，但可以阅读所有内容。\n",
    "\n",
    "The GitHub pages for this project are at\n",
    "\n",
    "    https://github.com/rlabbe/Kalman-and-Bayesian-Filters-in-Python \n",
    "\n",
    "\n",
    "<b>binder</b>\n",
    "\n",
    "binder serves interactive notebooks online, so you can run the code and change the code within your browser without downloading the book or installing Jupyter. Use this link to access the book via binder:\n",
    "\n",
    "Binder 在线提供交互式笔记本，因此您可以在浏览器中运行代码并更改代码，而无需下载本书或安装 Jupyter。使用此链接通过 Binder 访问本书：\n",
    "\n",
    "    http://mybinder.org/repo/rlabbe/Kalman-and-Bayesian-Filters-in-Python\n",
    "\n",
    "<b>nbviewer</b>\n",
    "\n",
    "The nbviewer website will render any Notebook in a static format. I find it does a slightly better job than the GitHub renderer, but it is slighty harder to use. It accesses GitHub directly; whatever I have checked into GitHub will be rendered by nbviewer.\n",
    "\n",
    "nbviewer 网站将以静态格式呈现任何 Notebook。我发现它比 GitHub 渲染器做得更好，但使用起来稍微困难一些。它直接访问 GitHub；我签入 GitHub 的任何内容都将由 nbviewer 呈现。\n",
    "\n",
    "You may access this book via nbviewer here:\n",
    "\n",
    "您可以通过 nbviewer 访问本书：\n",
    "\n",
    "http://nbviewer.ipython.org/github/rlabbe/Kalman-and-Bayesian-Filters-in-Python/blob/master/table_of_contents.ipynb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PDF Version"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I periodically generate a PDF of the book from the notebooks. You can access it here:\n",
    "\n",
    "https://drive.google.com/file/d/0By_SW19c1BfhSVFzNHc0SjduNzg/view?usp=sharing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Downloading and Running the Book"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, this book is intended to be interactive and I recommend using it in that form. It's a little more effort to set up, but worth it. If you install IPython and some supporting libraries  on your computer and then clone this book you will be able to run all of the code in the book yourself. You can perform experiments, see how filters react to different data, see how different filters react to the same data, and so on. I find this sort of immediate feedback both vital and invigorating. You do not have to wonder \"what happens if\". Try it and see!\n",
    "\n",
    "但是，本书旨在实现交互，我建议以这种形式使用它。设置起来需要多花一点功夫，但值得。如果您在计算机上安装 IPython 和一些支持库，然后克隆本书，您将能够自己运行本书中的所有代码。您可以进行实验，查看过滤器如何对不同数据做出反应，查看不同过滤器如何对相同数据做出反应，等等。我发现这种即时反馈既重要又令人振奋。您不必想知道“如果会发生什么”。试试看！\n",
    "\n",
    "Instructions for installation can be found in the Installation appendix, found [here](http://nbviewer.ipython.org/github/rlabbe/Kalman-and-Bayesian-Filters-in-Python/blob/master/Appendix-A-Installation.ipynb).\n",
    "\n",
    "安装说明可以在安装附录中找到，位于[此处](http://nbviewer.ipython.org/github/rlabbe/Kalman-and-Bayesian-Filters-in-Python/blob/master/Appendix-A-Installation.ipynb)。\n",
    "\n",
    "Once the software is installed you can navigate to the installation directory and run Juptyer notebook with the command line instruction\n",
    "\n",
    "软件安装完成后，你可以导航到安装目录并使用命令行指令运行 Jupyter Notebook\n",
    "\n",
    "    jupyter notebook\n",
    "\n",
    "This will open a browser window showing the contents of the base directory. The book is organized into chapters. Each chapter is named *xx*-*name*.ipynb, where *xx* is the chapter number. .ipynb is the Notebook file extension. To read Chapter 2, click on the link for chapter 2. This will cause the browser to open that subdirectory. In each subdirectory there will be one or more IPython Notebooks (all notebooks have a .ipynb file extension). The chapter contents are in the notebook with the same name as the chapter name. There are sometimes supporting notebooks for doing things like generating animations that are displayed in the chapter. These are not intended to be read by the end user, but of course if you are curious as to how an animation is made go ahead and take a look.\n",
    "\n",
    "这将打开一个浏览器窗口，其中显示基础目录的内容。本书分为几章。每章名为 *xx*-*name*.ipynb，其中 *xx* 是章节编号。.ipynb 是 Notebook 文件扩展名。要阅读第 2 章，请点击第 2 章的链接。这将导致浏览器打开该子目录。每个子目录中都会有一个或多个 IPython Notebook（所有 Notebook 都有 .ipynb 文件扩展名）。章节内容位于与章节名称同名的笔记本中。有时会有支持笔记本来执行诸如生成在章节中显示的动画之类的操作。这些并不是为了让最终用户阅读的，但是当然，如​​果您对动画的制作方式感到好奇，请继续查看。\n",
    "\n",
    "Admittedly this is a cumbersome interface to a book. I am following in the footsteps of several other projects that are re-purposing Jupyter Notebook to generate entire books. I feel the slight annoyances have a huge payoff - instead of having to download a separate code base and run it in an IDE while you try to read a book, all of the code and text is in one place. If you want to alter the code, you may do so and immediately see the effects of your change. If you find a bug, you can make a fix, and push it back to my repository so that everyone in the world benefits. And, of course, you will never encounter a problem I face all the time with traditional books - the book and the code are out of sync with each other, and you are left scratching your head as to which source to trust.\n",
    "\n",
    "无可否认，这是一个繁琐的图书界面。我正在追随其他几个项目的脚步，这些项目正在重新利用 Jupyter Notebook 来生成整本书。我觉得这些小小的烦恼会带来巨大的回报——你不必在阅读一本书时下载单独的代码库并在 IDE 中运行它，所有的代码和文本都在一个地方。如果你想修改代码，你可以这样做，并立即看到更改的效果。如果你发现一个错误，你可以修复它，然后将其推送回我的存储库，这样世界上的每个人都会受益。当然，你永远不会遇到我在传统书籍中经常遇到的问题——书和代码彼此不同步，你只能摸不着头脑，不知道该信任哪个来源。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jupyter\n",
    "\n",
    "First, some words about using Jupyter Notebooks with this book. This book is interactive. If you want to run code examples, and especially if you want to see animated plots, you will need to run the code cells. I cannot teach you everything about Jupyter Notebooks. However, a few things trip readers up. You can go to http://jupyter.org/ for detailed documentation.\n",
    "\n",
    "首先，介绍一下如何使用 Jupyter Notebooks 和本书。本书是交互式的。如果你想运行代码示例，尤其是如果你想查看动画图，你需要运行代码单元。我无法教你关于 Jupyter Notebooks 的所有内容。但是，有些东西会让读者感到困惑。你可以访问 http://jupyter.org/ 获取详细文档。\n",
    "\n",
    "First, you must always run the topmost code cell, the one with the comment `#format the book`. It is directly above. This does not just set up formatting, which you might not care about, but it also loads some necessary modules and makes some global settings regarding plotting and printing. So, always run this cell unless you are just passively reading. \n",
    "\n",
    "首先，您必须始终运行最上面的代码单元，即带有注释“#format the book”的代码单元。它就在上方。这不仅设置格式（您可能不关心），而且还加载一些必要的模块并进行一些有关绘图和打印的全局设置。因此，除非您只是被动阅读，否则请始终运行此单元。\n",
    "\n",
    "The line\n",
    "\n",
    "```python\n",
    "%matplotlib inline\n",
    "```\n",
    "causes plots to be displayed inside the notebook. Matplotlib is a plotting package which is described below. For reasons I don't understand the default behavior of Jupyter Notebooks is to generate plots in an external window. \n",
    "\n",
    "导致图表显示在笔记本内。Matplotlib 是一个绘图包，如下所述。由于我不明白的原因，Jupyter Notebooks 的默认行为是在外部窗口中生成图表。\n",
    "\n",
    "The percent sign in `%matplotlib` is used for IPython *magic* - these are commands to the kernel to do things that are not part of the Python language. There are many useful magic commands, and you can read about them here: http://ipython.readthedocs.io/en/stable/interactive/magics.html \n",
    "\n",
    "`%matplotlib` 中的百分号用于 IPython *magic* - 这些是内核命令，用于执行不属于 Python 语言的事情。有许多有用的魔法命令，您可以在此处阅读它们：http://ipython.readthedocs.io/en/stable/interactive/magics.html\n",
    "\n",
    "Running the code inside a cell is easy. Click on it so that it has focus (a box will be drawn around it), and then press CTRL-Enter. \n",
    "\n",
    "在单元格内运行代码很容易。单击它，使其获得焦点（将在其周围绘制一个框），然后按 CTRL-Enter。\n",
    "\n",
    "Second, cells must be run in order. I break problems up over several cells; if you try to just skip down and run the tenth code cell it almost certainly won't work. If you haven't run anything yet just choose *Run All Above* from the **Cell** menu item. That's the easiest way to ensure everything has been run.\n",
    "\n",
    "其次，单元格必须按顺序运行。我将问题分解为几个单元格；如果您尝试直接跳到下方并运行第十个代码单元格，则几乎肯定不会成功。如果您尚未运行任何内容，只需从 **单元格** 菜单项中选择 *运行以上所有内容*。这是确保所有内容都已运行的最简单方法。\n",
    "\n",
    "Once cells are run you can often jump around and rerun cells in different orders, but not always. I'm trying to fix this, but there is a tradeoff. I'll define a variable in cell 10 (say), and then run code that modifies that variable in cells 11 and 12. If you go back and run cell 11 again the variable will have the value that was set in cell 12, and the code expects the value that was set in cell 10. So, occasionally you'll get weird results if you run cells out of order. My advise is to backtrack a bit, and run cells in order again to get back to a proper state. It's annoying, but the interactive aspect of Jupyter notebooks more than makes up for it. Better yet, submit an issue on GitHub so I know about the problem and fix it!\n",
    "\n",
    "一旦运行单元格，您通常可以跳转并以不同的顺序重新运行单元格，但并非总是如此。我正在尝试解决这个问题，但这是有代价的。我将在单元格 10（例如）中定义一个变量，然后在单元格 11 和 12 中运行修改该变量的代码。如果您返回并再次运行单元格 11，则变量将具有在单元格 12 中设置的值，并且代码需要单元格 10 中设置的值。因此，如果您无序运行单元格，偶尔会得到奇怪的结果。我的建议是回溯一点，然后再次按顺序运行单元格以恢复到正确状态。这很烦人，但 Jupyter 笔记本的交互性足以弥补这一点。更好的是，在 GitHub 上提交问题，这样我就可以知道问题并修复它！\n",
    "\n",
    "Finally, some readers have reported problems with the animated plotting features in some browsers. I have not been able to reproduce this. In parts of the book I use the `%matplotlib notebook` magic, which enables interactive plotting. If these plots are not working for you, try changing this to read `%matplotlib inline`. You will lose the animated plotting, but it seems to work on all platforms and browsers.\n",
    "\n",
    "最后，一些读者报告了某些浏览器中动画绘图功能的问题。我无法重现这一点。在本书的部分内容中，我使用了`%matplotlib notebook`魔法，它可以实现交互式绘图。如果这些绘图对您不起作用，请尝试将其更改为`%matplotlib inline`。您将失去动画绘图，但它似乎适用于所有平台和浏览器。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SciPy, NumPy, and Matplotlib\n",
    "\n",
    "SciPy is a open source collection of software for mathematics. Included in SciPy are NumPy, which provides array objects, linear algebra, random numbers, and more. Matplotlib provides plotting of NumPy arrays. SciPy's modules duplicate some of the functionality in NumPy while adding features such as optimization, image processing, and more.\n",
    "\n",
    "SciPy 是一个开源数学软件集合。SciPy 中包含 NumPy，它提供数组对象、线性代数、随机数等。Matplotlib 提供 NumPy 数组的绘图。SciPy 的模块复制了 NumPy 中的一些功能，同时添加了优化、图像处理等功能。\n",
    "\n",
    "To keep my efforts for this book managable I have elected to assume that you know how to program in Python, and that you also are familiar with these packages. Nonetheless, I will take a few moments to illustrate a few features of each; realistically you will have to find outside sources to teach you the details. The home page for SciPy, https://scipy.org, is the perfect starting point, though you will soon want to search for relevant tutorials and/or videos.\n",
    "\n",
    "为了让本书的写作工作更容易完成，我选择假设您知道如何使用 Python 编程，并且您也熟悉这些软件包。尽管如此，我还是会花一些时间来说明每个软件包的一些功能；实际上，您必须找到外部资源来教您详细信息。SciPy 的主页 https://scipy.org 是完美的起点，尽管您很快就会想要搜索相关的教程和/或视频。\n",
    "\n",
    "NumPy, SciPy, and Matplotlib do not come with the default Python distribution; see the *Installation* Appendix if you do not have them installed.\n",
    "\n",
    "NumPy、SciPy 和 Matplotlib 不附带默认的 Python 发行版；如果您没有安装它们，请参阅*安装*附录。\n",
    "\n",
    "I use NumPy's array data structure throughout the book, so let's learn about them now. I will teach you enough to get started; refer to NumPy's documentation if you want to become an expert.\n",
    "\n",
    "我在整本书中都使用了 NumPy 的数组数据结构，所以现在让我们来了解一下它们。我会教你足够的入门知识；如果你想成为专家，请参阅 NumPy 的文档。\n",
    "\n",
    "`numpy.array` implements a one or more dimensional array. Its type is `numpy.ndarray`, and we will refer to this as an ndarray for short. You can construct it with any list-like object. The following constructs a 1-D array from a list:\n",
    "\n",
    "`numpy.array` 实现一维或多维数组。它的类型是 `numpy.ndarray`，我们将其简称为 ndarray。你可以用任何类似列表的对象来构造它。以下从列表构造一个一维数组："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = np.array([1, 2, 3])\n",
    "print(type(x))\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It has become a industry standard to use `import numpy as np`. \n",
    "\n",
    "使用`import numpy as np`已成为行业标准。\n",
    "\n",
    "You can also use tuples:\n",
    "\n",
    "您还可以使用元组："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5, 6])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array((4,5,6))\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create multidimensional arrays with nested brackets:\n",
    "\n",
    "使用嵌套括号创建多维数组："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1, 2, 3],\n",
    "              [4, 5, 6]])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can create arrays of 3 or more dimensions, but we have no need for that here, and so I will not elaborate.\n",
    "\n",
    "您可以创建 3 维或更多维的数组，但我们这里不需要这样做，所以我就不详细说明了。\n",
    "\n",
    "By default the arrays use the data type of the values in the list; if there are multiple types then it will choose the type that most accurately represents all the values. So, for example, if your list contains a mix of `int` and `float` the data type of the array would be of type `float`. You can override this with the `dtype` parameter.\n",
    "\n",
    "默认情况下，数组使用列表中值的数据类型；如果有多种类型，那么它将选择最准确表示所有值的类型。因此，例如，如果您的列表包含`int`和`float`的混合，则数组的数据类型将为`float`类型。您可以使用`dtype`参数覆盖它。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 2. 3.]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 2, 3], dtype=float)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can access the array elements using subscript location:\n",
    "\n",
    "您可以使用下标位置访问数组元素："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1, 2, 3],\n",
    "              [4, 5, 6]])\n",
    "\n",
    "print(x[1,2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can access a column or row by using slices. A colon (:) used as a subscript is shorthand for all data in that row or column. So `x[:,0]` returns an array of all data in the first column (the 0 specifies the first column):\n",
    "\n",
    "您可以使用切片来访问列或行。用作下标的冒号 (:) 是该行或列中所有数据的简写。因此 `x[:,0]` 返回第一列中所有数据的数组（0 指定第一列）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[:, 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can get the second row with:\n",
    "\n",
    "我们可以使用以下方法获得第二行："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 5, 6])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[1, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get the last two elements of the second row with:\n",
    "\n",
    "使用以下命令获取第二行的最后两个元素："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[1, 1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with Python `list`s, you can use negative indexes to refer to the end of the array. -1 refers to the last index. So another way to get the last two elements of the second (last) row would be:\n",
    "\n",
    "与 Python `list`的一样，您可以使用负索引来引用数组的末尾。-1 表示最后一个索引。因此，获取第二行（最后一行）的最后两个元素的另一种方法是："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[-1, -2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can perform matrix addition with the `+` operator, but matrix multiplication requires the `dot` method or function. The `*` operator performs element-wise multiplication, which is **not** what you want for linear algebra.\n",
    "\n",
    "您可以使用 `+` 运算符执行矩阵加法，但矩阵乘法需要 `dot` 方法或函数。`*` 运算符执行逐元素乘法，这对于线性代数来说**不是**你想要的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "addition:\n",
      " [[2. 4.]\n",
      " [6. 8.]]\n",
      "\n",
      "element-wise multiplication\n",
      " [[ 1.  4.]\n",
      " [ 9. 16.]]\n",
      "\n",
      "multiplication\n",
      " [[ 7. 10.]\n",
      " [15. 22.]]\n",
      "\n",
      "dot is also a member of np.array\n",
      " [[ 7. 10.]\n",
      " [15. 22.]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1., 2.],\n",
    "              [3., 4.]])\n",
    "print('addition:\\n', x + x)\n",
    "print('\\nelement-wise multiplication\\n', x * x)\n",
    "print('\\nmultiplication\\n', np.dot(x, x))\n",
    "print('\\ndot is also a member of np.array\\n', x.dot(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 3.5 introduced the `@` operator for matrix multiplication.\n",
    "\n",
    "Python 3.5 引入了用于矩阵乘法的 `@` 运算符。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 7., 10.],\n",
       "       [15., 22.]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x @ x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will only work if you are using Python 3.5+. This book requires 3.6 or later, so I will use it whenever I can. Note that the operator requires that both values are arrays. Hence, `x @ 3.` raises a ValueError whereas `np.dot(X, 3.)` works fine.\n",
    "\n",
    "这仅在您使用 Python 3.5+ 时才有效。本书需要 3.6 或更高版本，因此我会尽可能使用它。请注意，运算符要求两个值都是数组。因此，`x @ 3.`会引发 ValueError，而`np.dot(X, 3.)`可以正常工作。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can get the transpose with `.T`, and the inverse with `numpy.linalg.inv`. The SciPy package also provides the inverse function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "transpose\n",
      " [[1. 3.]\n",
      " [2. 4.]]\n",
      "\n",
      "NumPy ninverse\n",
      " [[-2.   1. ]\n",
      " [ 1.5 -0.5]]\n",
      "\n",
      "SciPy inverse\n",
      " [[-2.   1. ]\n",
      " [ 1.5 -0.5]]\n"
     ]
    }
   ],
   "source": [
    "import scipy.linalg as linalg\n",
    "print('transpose\\n', x.T)\n",
    "print('\\nNumPy ninverse\\n', np.linalg.inv(x))\n",
    "print('\\nSciPy inverse\\n', linalg.inv(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are helper functions like `zeros` to create a matrix of all zeros, `ones` to get all ones, and `eye` to get the identity matrix. If you want a multidimensional array, use a tuple to specify the shape.\n",
    "\n",
    "有一些辅助函数，例如 `zeros` 可以创建全零矩阵，`ones` 可以获取全一矩阵，`eye` 可以获取单位矩阵。如果您想要多维数组，请使用元组来指定形状。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "zeros\n",
      " [0. 0. 0. 0. 0. 0. 0.]\n",
      "\n",
      "zeros(3x2)\n",
      " [[0. 0.]\n",
      " [0. 0.]\n",
      " [0. 0.]]\n",
      "\n",
      "eye\n",
      " [[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "print('zeros\\n', np.zeros(7))\n",
    "print('\\nzeros(3x2)\\n', np.zeros((3, 2)))\n",
    "print('\\neye\\n', np.eye(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have functions to create equally spaced data. `arange` works much like Python's `range` function, except it returns a NumPy array. `linspace` works slightly differently, you call it with `linspace(start, stop, num)`, where `num` is the length of the array that you want.\n",
    "\n",
    "我们有创建等距数据的函数。`arange` 的工作方式与 Python 的 `range` 函数非常相似，只是它返回一个 NumPy 数组。`linspace` 的工作方式略有不同，你可以用 `linspace(start, stop, num)` 来调用它，其中 `num` 是你想要的数组的长度。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. , 1.1,\n",
       "       1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(0, 2, 0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.   , 0.105, 0.211, 0.316, 0.421, 0.526, 0.632, 0.737, 0.842,\n",
       "       0.947, 1.053, 1.158, 1.263, 1.368, 1.474, 1.579, 1.684, 1.789,\n",
       "       1.895, 2.   ])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0, 2, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's plot some data. For the most part it is very simple. Matplotlib contains a plotting library `pyplot`. It is industry standard to import it as `plt`. Once imported, plot numbers by calling `plt.plot` with a list or array of numbers. If you make multiple calls it will plot multiple series, each with a different color.\n",
    "\n",
    "现在让我们绘制一些数据。大部分都很简单。Matplotlib 包含一个绘图库`pyplot`。将其导入为`plt`是行业标准。导入后，通过使用数字列表或数组调用`plt.plot`来绘制数字。如果您多次调用，它将绘制多个系列，每个系列都有不同的颜色。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x1ecdb844b80>]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "a = np.array([6, 3, 5, 2, 4, 1])\n",
    "plt.plot([1, 4, 2, 5, 3, 6])\n",
    "plt.plot(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output `[<matplotlib.lines.Line2D at 0x2ba160bed68>]` is because `plt.plot` returns the object that was just created. Ordinarily we do not want to see that, so I add a `;` to my last plotting command to suppress that output.\n",
    "\n",
    "输出 `[<matplotlib.lines.Line2D at 0x2ba160bed68>]` 是因为 `plt.plot` 返回了刚刚创建的对象。通常我们不想看到这个，所以我在最后一个绘图命令中添加了一个 `;` 来抑制该输出。\n",
    "\n",
    "By default `plot` assumes that the x-series is incremented by one. You can provide your own x-series by passing in both x and y.\n",
    "\n",
    "默认情况下，`plot` 假设 x 系列增加一。您可以通过传入 x 和 y 来提供自己的 x 系列。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(np.arange(0,1, 0.1), [1,4,3,2,6,4,7,3,4,5]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are many more features to these packages which I use in this book. Normally I will introduce them without explanation, trusting that you can infer the usage from context, or search online for an explanation. As always, if you are unsure, create a new cell in the Notebook or fire up a Python console and experiment!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise -  Create arrays\n",
    "\n",
    "I want you to create a NumPy array of 10 elements with each element containing 1/10. There are several ways to do this; try to implement as many as you can think of. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# your solution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution\n",
    "\n",
    "Here are three ways to do this. The first one is the one I want you to know. I used the '/' operator to divide all of the elements of the array with 10. We will shortly use this to convert the units of an array from meters to km."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1]\n",
      "[0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1]\n",
      "[0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1]\n"
     ]
    }
   ],
   "source": [
    "print(np.ones(10) / 10.)\n",
    "print(np.array([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1]))\n",
    "print(np.array([.1] * 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is one I haven't covered yet. The function `numpy.asarray()` will convert its argument to an ndarray if it isn't already one. If it is, the data is unchanged. This is a handy way to write a function that can accept either Python lists or ndarrays, and it is very efficient if the type is already ndarray as nothing new is created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.1 0.2 0.3]\n",
      "[0.4 0.5 0.6]\n"
     ]
    }
   ],
   "source": [
    "def one_tenth(x):\n",
    "    x = np.asarray(x)\n",
    "    return x / 10.\n",
    "\n",
    "print(one_tenth([1, 2, 3]))            # I work!\n",
    "print(one_tenth(np.array([4, 5, 6])))  # so do I!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Companion Software"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I am writing an open source Bayesian filtering Python library called FilterPy. Installation instructions are given above.\n",
    "\n",
    "FilterPy is hosted GitHub at (https://github.com/rlabbe/filterpy) but the `pip` installed version should serve your needs.\n",
    "\n",
    "Code that is specific to the book is stored with the book in the subdirectory **/kf_book**. It contains code for formatting the book. It also contains python files with names like *xxx*_internal.py. I use these to store functions that are useful for a specific chapter. This allows me to hide Python code that is not particularly interesting to read - I may be generating a plot or chart, and I want you to focus on the contents of the chart, not the mechanics of how I generate that chart with Python. If you are curious as to the mechanics of that, just go and browse the source.\n",
    "\n",
    "Some chapters introduce functions that are useful for the rest of the book. Those functions are initially defined within the Notebook itself, but the code is also stored in a Python file in **/kf_book** that is imported if needed in later chapters. I do document when I do this where the function is first defined, but this is still a work in progress. I try to avoid this because then I always face the issue of code in the directory becoming out of sync with the code in the book. However, Jupyter Notebook does not give us a way to refer to code cells in other notebooks, so this is the only mechanism I know of to share functionality across notebooks.\n",
    "\n",
    "There is an undocumented directory called **/experiments**. This is where I write and test code prior to putting it in the book. There is some interesting stuff in there, and feel free to look at it. As the book evolves I plan to create examples and projects, and a lot of this material will end up there. Small experiments will eventually just be deleted. If you are just interested in reading the book you can safely ignore this directory. \n",
    "\n",
    "\n",
    "The directory **/kf_book** contains a css file containing the style guide for the book. The default look and feel of Jupyter Notebook is rather plain. I have followed the examples set by books such as [Probabilistic Programming and Bayesian Methods for Hackers](http://nbviewer.ipython.org/github/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/blob/master/Chapter1_Introduction/Chapter1.ipynb) [2]. I have also been very influenced by Professor Lorena Barba's fantastic work, [available here](https://github.com/barbagroup/CFDPython) [3]. I owe all of my look and feel to the work of these projects. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Thoughts on Python and Coding Math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most Kalman filtering and other engineering texts are written by mathematicians or academics. When there is software (rarely), it is not production quality. Take Paul Zarchan's book *Fundamentals of Kalman Filtering* as an example. This is a fantastic book which belongs in your library, and is one of the few books that provides full source for every example and chart. But the code is Fortran without any subroutines beyond calls to functions like `MATMUL`. Kalman filters are re-implemented throughout the book. The same listing mixes simulation with filtering code, making it hard to distinguish them. Some chapters implement the same filter in subtly different ways, and uses bold text to highlight the few lines that changed. If Runge Kutta is needed it is embedded in the code, without comments. \n",
    "\n",
    "There's a better way. If I want to perform Runge Kutta I call `ode45`, I do not embed an Runge Kutta implementation in my code. I don't want to implement Runge Kutta multiple times and debug it several times. if I do find a bug, I can fix it once and be assured that it now works across all my different projects. And, it is readable. It is rare that I care about the implementation of Runge Kutta.\n",
    "\n",
    "This is a textbook on Kalman filtering, and you can argue that we *do* care about the implementation of Kalman filters. That is true, but the code that performs the filtering uses about 10 lines of code. The code to implement the math is fairly trivial. Most of the work that Kalman filter requires is the design of the matrices that get fed into the math engine.\n",
    "\n",
    "A possible downside is that the equations that perform the filtering are hidden behind functions, which we could argue is a loss in a pedagogical text. I argue the converse. I want you to learn how to use Kalman filters in the real world, for real projects, and you shouldn't be cutting and pasting established algorithms all over the place.\n",
    "\n",
    "I use Python classes. I mostly use classes as a way to organize the data that the filters require, not to implement object oriented (OO) features such as inheritence. For example, the `KalmanFilter` class stores matrices and vectors called `x`, `P`, `R`, `Q`, `S`, `y`, `K`. I've seen procedural libraries for Kalman filters, and they require the programmer to maintain all of those matrices. This perhaps isn't so bad for a toy program, but program a bank of Kalman filters and you will not enjoy having to manage all of those matrices and other associated data. I have derived from these classes occasionally in my own work, and find it handy, but I don't want to force OO on people as I know many do not like it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## License"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc-sa/4.0/\"><img alt=\"Creative Commons License\" style=\"border-width:0\" src=\"http://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png\" /></a><br /><span xmlns:dct=\"http://purl.org/dc/terms/\" property=\"dct:title\">Kalman Filters and Random Signals in Python</span> by <a xmlns:cc=\"http://creativecommons.org/ns#\" href=\"https://github.com/rlabbe/Kalman-Filters-and-Random-Signals-in-Python\" property=\"cc:attributionName\" rel=\"cc:attributionURL\">Roger Labbe</a> is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc-sa/4.0/\">Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License</a>.<br />\n",
    "\n",
    "http://creativecommons.org/licenses/by-nc-sa/4.0/\n",
    "\n",
    "Based on the work at <a xmlns:dct=\"http://purl.org/dc/terms/\" href=\"https://github.com/rlabbe/Kalman-and-Bayesian-Filters-in-Python\" rel=\"dct:source\">https://github.com/rlabbe/Kalman-and-Bayesian-Filters-in-Python</a>."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contact"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "rlabbejr@gmail.com"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resources"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* [1] http://www.greenteapress.com/\n",
    "* [2] http://nbviewer.ipython.org/github/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/blob/master/Chapter1_Introduction/Chapter1.ipynb\n",
    "* [3] https://github.com/barbagroup/CFDPython"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  },
  "nbdime-conflicts": {
   "local_diff": [
    {
     "diff": [
      {
       "diff": [
        {
         "diff": [
          {
           "key": 4,
           "op": "addrange",
           "valuelist": "10"
          },
          {
           "key": 4,
           "length": 1,
           "op": "removerange"
          }
         ],
         "key": 0,
         "op": "patch"
        }
       ],
       "key": "version",
       "op": "patch"
      }
     ],
     "key": "language_info",
     "op": "patch"
    }
   ],
   "remote_diff": [
    {
     "diff": [
      {
       "diff": [
        {
         "key": 0,
         "length": 1,
         "op": "removerange"
        }
       ],
       "key": "version",
       "op": "patch"
      }
     ],
     "key": "language_info",
     "op": "patch"
    }
   ]
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
